"""
MyLangExtract 配置管理

提供配置文件加载、保存和环境变量管理功能
"""

import os
import json
from typing import Dict, Any, Optional
from pathlib import Path


def get_config_dir() -> Path:
    """获取配置目录路径"""
    home = Path.home()
    config_dir = home / ".mylangextract"
    config_dir.mkdir(exist_ok=True)
    return config_dir


def get_config_file() -> Path:
    """获取配置文件路径"""
    return get_config_dir() / "config.json"


def load_config() -> Dict[str, Any]:
    """加载配置文件
    
    Returns:
        配置字典
    """
    config_file = get_config_file()
    
    if not config_file.exists():
        return {}
    
    try:
        with open(config_file, 'r', encoding='utf-8') as f:
            return json.load(f)
    except (json.JSONDecodeError, IOError) as e:
        print(f"警告: 无法加载配置文件 {config_file}: {e}")
        return {}


def save_config(config: Dict[str, Any]) -> bool:
    """保存配置文件
    
    Args:
        config: 配置字典
        
    Returns:
        是否保存成功
    """
    config_file = get_config_file()
    
    try:
        with open(config_file, 'w', encoding='utf-8') as f:
            json.dump(config, f, ensure_ascii=False, indent=2)
        return True
    except IOError as e:
        print(f"错误: 无法保存配置文件 {config_file}: {e}")
        return False


def get_api_key(provider: str, config: Optional[Dict[str, Any]] = None) -> Optional[str]:
    """获取 API 密钥
    
    按以下优先级获取：
    1. 传入的配置字典
    2. 环境变量
    3. 配置文件
    
    Args:
        provider: 提供商名称
        config: 可选的配置字典
        
    Returns:
        API 密钥，如果未找到则返回 None
    """
    from ..providers.presets import get_env_var_name
    
    # 1. 从传入的配置获取
    if config and "api_keys" in config and provider in config["api_keys"]:
        return config["api_keys"][provider]
    
    # 2. 从环境变量获取
    env_var = get_env_var_name(provider)
    if env_var:
        api_key = os.getenv(env_var)
        if api_key:
            return api_key
    
    # 3. 从配置文件获取
    file_config = load_config()
    if "api_keys" in file_config and provider in file_config["api_keys"]:
        return file_config["api_keys"][provider]
    
    return None


def set_api_key(provider: str, api_key: str) -> bool:
    """设置 API 密钥到配置文件
    
    Args:
        provider: 提供商名称
        api_key: API 密钥
        
    Returns:
        是否设置成功
    """
    config = load_config()
    
    if "api_keys" not in config:
        config["api_keys"] = {}
    
    config["api_keys"][provider] = api_key
    
    return save_config(config)


def remove_api_key(provider: str) -> bool:
    """从配置文件中移除 API 密钥
    
    Args:
        provider: 提供商名称
        
    Returns:
        是否移除成功
    """
    config = load_config()
    
    if "api_keys" in config and provider in config["api_keys"]:
        del config["api_keys"][provider]
        return save_config(config)
    
    return True  # 如果本来就不存在，也算成功


def list_configured_providers() -> Dict[str, bool]:
    """列出已配置的提供商
    
    Returns:
        提供商名称到是否已配置的映射
    """
    from ..providers.presets import PRESET_CONFIGS, get_env_var_name
    
    config = load_config()
    configured = {}
    
    for provider_name in PRESET_CONFIGS.keys():
        # 检查配置文件
        has_config_key = (
            "api_keys" in config and 
            provider_name in config["api_keys"] and 
            config["api_keys"][provider_name]
        )
        
        # 检查环境变量
        env_var = get_env_var_name(provider_name)
        has_env_key = env_var and bool(os.getenv(env_var))
        
        configured[provider_name] = has_config_key or has_env_key
    
    return configured


def get_default_provider() -> Optional[str]:
    """获取默认提供商
    
    Returns:
        默认提供商名称，如果未设置则返回 None
    """
    config = load_config()
    return config.get("default_provider")


def set_default_provider(provider: str) -> bool:
    """设置默认提供商
    
    Args:
        provider: 提供商名称
        
    Returns:
        是否设置成功
    """
    from ..providers.presets import get_preset_config
    
    # 验证提供商是否存在
    if not get_preset_config(provider):
        print(f"错误: 未知的提供商 '{provider}'")
        return False
    
    config = load_config()
    config["default_provider"] = provider
    
    return save_config(config)


def create_env_file_template() -> str:
    """创建环境变量文件模板
    
    Returns:
        .env 文件内容模板
    """
    from ..providers.presets import ENV_VAR_MAPPING
    
    lines = [
        "# MyLangExtract 环境变量配置",
        "# 请根据需要设置相应的 API 密钥",
        ""
    ]
    
    for provider, env_var in ENV_VAR_MAPPING.items():
        lines.append(f"# {provider}")
        lines.append(f"{env_var}=your_api_key_here")
        lines.append("")
    
    return "\n".join(lines)


def save_env_template(file_path: str = ".env") -> bool:
    """保存环境变量文件模板
    
    Args:
        file_path: 文件路径，默认为 ".env"
        
    Returns:
        是否保存成功
    """
    try:
        template = create_env_file_template()
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(template)
        print(f"环境变量模板已保存到: {file_path}")
        return True
    except IOError as e:
        print(f"错误: 无法保存环境变量模板: {e}")
        return False


def validate_config() -> Dict[str, Any]:
    """验证当前配置
    
    Returns:
        验证结果字典
    """
    result = {
        "config_file_exists": get_config_file().exists(),
        "configured_providers": list_configured_providers(),
        "default_provider": get_default_provider(),
        "issues": []
    }
    
    # 检查是否有任何已配置的提供商
    configured_count = sum(1 for configured in result["configured_providers"].values() if configured)
    if configured_count == 0:
        result["issues"].append("未配置任何提供商的 API 密钥")
    
    # 检查默认提供商是否已配置
    default = result["default_provider"]
    if default and not result["configured_providers"].get(default, False):
        result["issues"].append(f"默认提供商 '{default}' 未配置 API 密钥")
    
    return result


def print_config_status():
    """打印配置状态"""
    print("MyLangExtract 配置状态")
    print("=" * 30)
    
    validation = validate_config()
    
    print(f"配置文件: {get_config_file()}")
    print(f"配置文件存在: {'是' if validation['config_file_exists'] else '否'}")
    
    default = validation["default_provider"]
    print(f"默认提供商: {default if default else '未设置'}")
    
    print("\n提供商配置状态:")
    for provider, configured in validation["configured_providers"].items():
        status = "✅ 已配置" if configured else "❌ 未配置"
        print(f"  {provider}: {status}")
    
    if validation["issues"]:
        print("\n⚠️  发现问题:")
        for issue in validation["issues"]:
            print(f"  - {issue}")
    else:
        print("\n✅ 配置正常")


# 命令行工具函数
def main():
    """命令行配置工具主函数"""
    import sys
    
    if len(sys.argv) < 2:
        print_config_status()
        return
    
    command = sys.argv[1]
    
    if command == "status":
        print_config_status()
    elif command == "set-key" and len(sys.argv) == 4:
        provider, api_key = sys.argv[2], sys.argv[3]
        if set_api_key(provider, api_key):
            print(f"✅ 已设置 {provider} 的 API 密钥")
        else:
            print(f"❌ 设置 {provider} 的 API 密钥失败")
    elif command == "remove-key" and len(sys.argv) == 3:
        provider = sys.argv[2]
        if remove_api_key(provider):
            print(f"✅ 已移除 {provider} 的 API 密钥")
        else:
            print(f"❌ 移除 {provider} 的 API 密钥失败")
    elif command == "set-default" and len(sys.argv) == 3:
        provider = sys.argv[2]
        if set_default_provider(provider):
            print(f"✅ 已设置默认提供商为 {provider}")
        else:
            print(f"❌ 设置默认提供商失败")
    elif command == "create-env":
        file_path = sys.argv[2] if len(sys.argv) > 2 else ".env"
        save_env_template(file_path)
    else:
        print("用法:")
        print("  python -m MyLangExtract.utils.config status")
        print("  python -m MyLangExtract.utils.config set-key <provider> <api_key>")
        print("  python -m MyLangExtract.utils.config remove-key <provider>")
        print("  python -m MyLangExtract.utils.config set-default <provider>")
        print("  python -m MyLangExtract.utils.config create-env [file_path]")


if __name__ == "__main__":
    main()
